home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1995 November / EnigmA AMIGA RUN 02 (1995)(G.R. Edizioni)(IT)[!][issue 1995-11][Skylink CD].iso / earcd / program / misc / fpl-v13.lha / fpl / src / reference.c < prev    next >
C/C++ Source or Header  |  1995-06-28  |  9KB  |  281 lines
  1. /******************************************************************************
  2.  *              FREXX PROGRAMMING LANGUAGE                  *
  3.  ******************************************************************************
  4.  
  5.  Reference.c
  6.  
  7.  Routines for interpreting variable references from the interface function.
  8.  
  9.  *****************************************************************************/
  10.  
  11. /************************************************************************
  12.  *                                                                      *
  13.  * fpl.library - A shared library interpreting script langauge.         *
  14.  * Copyright (C) 1992-1994 FrexxWare                                    *
  15.  * Author: Daniel Stenberg                                              *
  16.  *                                                                      *
  17.  * This program is free software; you may redistribute for non          *
  18.  * commercial purposes only. Commercial programs must have a written    *
  19.  * permission from the author to use FPL. FPL is *NOT* public domain!   *
  20.  * Any provided source code is only for reference and for assurance     *
  21.  * that users should be able to compile FPL on any operating system     *
  22.  * he/she wants to use it in!                                           *
  23.  *                                                                      *
  24.  * You may not change, resource, patch files or in any way reverse      *
  25.  * engineer anything in the FPL package.                                *
  26.  *                                                                      *
  27.  * This program is distributed in the hope that it will be useful,      *
  28.  * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
  29.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                 *
  30.  *                                                                      *
  31.  * Daniel Stenberg                                                      *
  32.  * Ankdammsgatan 36, 4tr                                                *
  33.  * S-171 43 Solna                                                       *
  34.  * Sweden                                                               *
  35.  *                                                                      *
  36.  * FidoNet 2:201/328    email:dast@sth.frontec.se                       *
  37.  *                                                                      *
  38.  ************************************************************************/
  39.  
  40. #include <stddef.h>
  41. #include "script.h"
  42.  
  43. #if defined(UNIX)
  44. #include <stdio.h>
  45. #endif
  46.  
  47. #include "reference.h"
  48.  
  49. struct fplStr EmptyString={0,0,0};
  50.  
  51. #ifndef AMIGA /* if not using SAS/C on Amiga */
  52.  
  53. #ifdef VARARG_FUNCTIONS
  54.  
  55. /*
  56.  * The following stub functions to the actual library functions was done
  57.  * to make this run under SunOS 4.1.x using gcc. Thanks to Bernd Noll
  58.  * (b_noll@sun.rhrk.un) for this contribution!
  59.  */
  60.  
  61. long fplReferenceTags(void *anchor, void *refID, ...)
  62. {
  63.   va_list tags;
  64.   long ret;
  65.   va_start(tags, format); /* get parameter list */
  66.   ret = fplReference(anchor, refID, (unsigned long *)tags);
  67.   va_end(tags)
  68.   return ret;
  69. }
  70.  
  71. #else /* VARARG_FUNCTIONS */
  72.  
  73. long fplReferenceTags(void *anchor, void *refID, unsigned long tags, ...)
  74. {
  75.   return(fplReference(anchor, refID, &tags));
  76. }
  77.  
  78. #endif
  79.  
  80. #endif
  81.  
  82. /**********************************************************************
  83.  *
  84.  * fplReference()
  85.  *
  86.  * Handles all referencing to FPL internal symbols from the interface
  87.  * function.
  88.  *
  89.  ******/
  90.  
  91. ReturnCode PREFIX
  92. fplReference(AREG(0) struct Data *scr,
  93.              AREG(1) struct Identifier *ident,
  94.              AREG(2) unsigned long *tags)
  95. {
  96.   ReturnCode ret = FPL_OK;
  97.   long item=0;
  98.   long a=0;
  99.   long *dims;
  100.   long my_strlen=-1;
  101.   struct fplRef *ref;
  102.   while(tags && *tags) {
  103.     switch(*tags++) {
  104.     case FPLREF_ARRAY_RESIZE:        /* version 11 magic! */
  105.       if(ident->flags&FPL_VARIABLE && ident->data.variable.num) {
  106.         /*
  107.          * It is a variable and it is at least a one dimensional array!
  108.          */
  109.         ref = (struct fplRef *)(*tags);
  110.         CALL( ArrayResize(scr,
  111.                           ref->Dimensions,
  112.                           ref->ArraySize,
  113.                           ident));
  114.       }
  115.       break;
  116.       
  117.     case FPLREF_ARRAY_ITEM:
  118.       if(ident->flags&FPL_VARIABLE) {
  119.     dims = (long *)(*tags);
  120.     while(dims[a]>0)
  121.       a++;
  122.     item = ArrayNum(a, ident->data.variable.num,
  123.             dims, ident->data.variable.dims);
  124.     if(item<0)
  125.       item=0; /* just ignore stupid values! */
  126.         a=0; /* reset 'a' again */
  127.       }
  128.       break;
  129.     case FPLREF_ARRAY_INFO:
  130.       /*
  131.        * Fill out the structure given to us by the caller!
  132.        */
  133.       if(ident->flags&FPL_VARIABLE && ident->data.variable.num) {
  134.     ref = (struct fplRef *)(*tags);
  135.     ref->Dimensions = ident->data.variable.num;  /* number of dims */
  136.     ref->ArraySize  = ident->data.variable.dims; /* actual dims */
  137.       }
  138.       break;
  139.     case FPLREF_NAME:
  140.       /*
  141.        * Receive name in supplied char pointer!
  142.        */
  143.       *(uchar **)(*tags) = ident->name;
  144.       break;
  145.     case FPLREF_TYPE:
  146.       /*
  147.        * Receive flags in supplied long!
  148.        */
  149.       *(long *)(*tags) =
  150.         (ident->flags&FPL_STRING_VARIABLE?FPLREF_TYPE_STRING:0)|
  151.       (ident->flags&FPL_INT_VARIABLE?FPLREF_TYPE_INTEGER:0)|
  152.         (ident->flags&FPL_VARIABLE?
  153.          (ident->data.variable.num?FPLREF_TYPE_ARRAY:0):0 )|
  154.            (ident->flags&FPL_FUNCTION?FPLREF_TYPE_FUNCTION:0);
  155.       break;
  156.  
  157.     case FPLREF_GET_STRING:
  158.       if(ident->flags&FPL_STRING_VARIABLE &&
  159.      item<ident->data.variable.size) {
  160.         if(ident->data.variable.var.str[item]) {
  161.           /*
  162.            * This is a string!
  163.            */
  164.           *(uchar **)(*tags) = ident->data.variable.var.str[item]->string;
  165.         }
  166.         else {
  167.           /*
  168.            * Can't return NULL for no string, return pointer to ""!
  169.            */
  170.           *(uchar **)(*tags) = EmptyString.string;
  171.         }
  172.       }
  173.       else {
  174.     *(uchar **)(*tags) = NULL;
  175.       }
  176.       break;
  177.  
  178.     case FPLREF_SET_MY_STRLEN:
  179.       my_strlen=(long)(*tags);
  180.       break;
  181.     case FPLREF_SET_MY_STRING:
  182.       a=1;
  183.     case FPLREF_SET_STRING:
  184.       if(ident->flags&FPL_STRING_VARIABLE &&
  185.      item<ident->data.variable.size &&
  186.          *tags) {
  187.     /*
  188.      * Get the allocation type.
  189.      */
  190.     uchar type=MALLOC_DYNAMIC; /* default memory state */
  191.     struct fplStr *str;
  192.     if(ident->data.variable.var.str[item]) {
  193.       type = TypeMem(ident->data.variable.var.str[item]);
  194.  
  195.       if(MALLOC_STATIC == type ) {
  196.         /*
  197.          * The previous allocation was static!
  198.          */
  199.         FREEA( ident->data.variable.var.str[item] );
  200.       }
  201.           else {
  202.             FREE( ident->data.variable.var.str[item] );
  203.           }
  204.     }
  205.     if(1 == a) {
  206.       /*
  207.        * This is a FPLREF_SET_MY_STRING call. That means we got a regular
  208.        * C style char pointer to a zero terminated string here, allocate
  209.        * a regular FPL string and copy the string into that one
  210.        */
  211.       register long len = 0>my_strlen?strlen((uchar *)*tags):my_strlen;
  212.           GETMEM(str, len + sizeof(struct fplStr));
  213.           str->alloc= len;
  214.           str->len= len; /* set default to entire string */
  215.  
  216.           /* copy the data into the string */
  217.           memcpy(str->string, (uchar *)(*tags), len);
  218.     }
  219.     else {
  220.           /*
  221.            * We received a pointer to the ->string member of a fplStr struct.
  222.            * Make 'str' point to the struct itself!
  223.            */
  224.       str = (struct fplStr *)
  225.         (((uchar *)(*tags)) - offsetof(struct fplStr, string));
  226.         }
  227.  
  228.     ident->data.variable.var.str[item] = str;
  229.  
  230.         str->string[str->len] = '\0'; /* force zero termination! */
  231.     
  232.     if(MALLOC_STATIC == type || ident->flags&FPL_EXPORT_SYMBOL) {
  233.       /*
  234.        * The previous memory was static, which probably means that
  235.        * this is an exported or global variable which required
  236.        * static existance. Swap it back to that state!
  237.        */
  238.       SwapMem(scr,
  239.                   ident->data.variable.var.str[item],
  240.                   MALLOC_STATIC);
  241.     }
  242.         else {
  243.           /*
  244.            * Make sure this allocation is dynamic!
  245.            */
  246.       SwapMem(scr,
  247.                   ident->data.variable.var.str[item],
  248.                   MALLOC_DYNAMIC);
  249.         }
  250.       }
  251.       else {
  252.     *(uchar **)(*tags) = NULL;
  253.       }
  254.       break;
  255.  
  256.     case FPLREF_GET_INTEGER:
  257.       if(ident->flags&FPL_INT_VARIABLE &&
  258.      item<ident->data.variable.size) {
  259.     /* we supply a pointer to it, then we can return NULL if there was
  260.        something that looked fishy! */
  261.         *(long **)(*tags) = &ident->data.variable.var.val32[item];
  262.       }
  263.       else {
  264.     *(long **)(*tags) = NULL;
  265.       }
  266.       break;
  267.  
  268.     case FPLREF_SET_INTEGER:
  269.       if(ident->flags&FPL_INT_VARIABLE &&
  270.          item<ident->data.variable.size) {
  271.     /* set integer variable item */
  272.         ident->data.variable.var.val32[item] = (*tags);
  273.       }
  274.       break;
  275.     }
  276.     tags++;
  277.   }
  278.   return ret;
  279. }
  280.  
  281.